Fonts provide a mapping between symbolic codes representing characters (letters, numerals, diacritical marks, typographic ornaments, and the like) and visual shapes. For example, the letter "A" is represented by the number 65 in the ASCII symbol set. Different fonts are used to express different type faces and styles that represent the same characters. In current computer-graphics practice, fonts are special objects known to a graphics subsystem. Further, in accordance with current computer-graphics practice, a set of fonts is available to user programs (also known as application programs) which use the given graphics subsystem via a set of definitions known as application program interfaces ("APIs"). The APIs define how a user program (or application program) selects appearance characteristics for rendering characters, such as type style, font face, size, color, and so forth. Then, using appropriate APIs, the user program requests the graphics subsystem to print/display, i.e., render, characters or text at a given position on an output device according to previously-selected appearance characteristics.
FIG. 1. shows an environment in which display and keyboard 100 are connected to processor and memory 200. Processor and memory 200 are connected to storage 300 and printer 400. As shown in FIG. 1, processor and memory 200 contain application program 210 and operating-environment 220 which interact with each other using predetermined APIs, which APIs are shown symbolically in FIG. 1 as API 230. As further shown in FIG. 1, fonts 310 are stored on storage 300. As is well known in the art, fonts 310 are accessed by application program 210 by making an appropriate call to operating-environment 220 using an appropriate one of the predetermined APIs. Operating-environment 220 causes fonts 310 to render a character for display on display 100 and/or printer 400.
In the prior art, in addition to appearance characteristics such as type style, font face, size and so forth, the application program must select color because a typical prior art font does not have embedded color. In this respect, a typical prior art font is like a rubber stamp that has no color of its own, i.e., with a rubber stamp characters are rendered in the color of the ink pad used to "paint" the rubber stamp. By analogy, a rubber stamp can render different colors by painting it with different inks and the same is true of typical prior art fonts.
There are many widely-used font technologies in the prior art but, in general, they break down into four basic font types. Although a few prior art fonts are hybrids of the four basic font types, that does not materially change the following discussion.
The first basic prior art font type is referred to as a bitmapped font. In accordance with this technology, a digital "picture" of a rendering of each letter in the alphabet is stored in a given size for a specific output resolution, style, and so forth. Typically, each digital picture is represented as an array of bits, with, for example, "1" bits representing positions in the array for a selected color to appear and "0" bits representing positions in the array for no color to appear. A few bitmapped fonts were produced and sold for use with Apple.TM. systems that contained color information for each position in the font. For those fonts, user-program-specified color information was simply ignored. Bitmapped fonts are problematic because they are only suitable for one size at one display resolution, i.e., they cannot be scaled.
The second basic prior art font type is referred to as a pure-outline font. Pure-outline fonts contain coded mathematical formulas and equations that describe the outlines. i.e., the shapes, of the edges of each character. These outlines are analogous to tiny dikes enclosing an area into which one would pour ink to render the completed character. In use, a font subsystem first mathematically converts the outlines to a requested size. Then, the font subsystem determines which pixels are inside the outlines. Finally, the font subsystem marks the output device in a user-selected color. As is well known, pure-outline fonts often contain "hinting" data that is used by the font subsystem, for example, to adjust small characters to make them more pleasing to the eye. In addition, pure-outline fonts are classified as "scalable," meaning that the same font description can be shrunk or enlarged, for example, mathematically, to describe the font in different sizes or in different hardware pixel resolutions.
The pure-outline font is today's dominant font technology, typified by Apple.TM. TrueType.TM. fonts and Adobe.TM. PostScript.TM. programming language Type 1 format fonts. As is well known, the PostScript.TM. programming language is a general purpose computer language which has a built-in graphics environment (see a book by Adobe Systems Incorporated entitled "PostScript Language Reference Manual"--Second Edition, Addison-Wesley, 1990. ISBN 0-201-18127-4 for a description of the PostScript.TM. programming language). In Apple.TM. Macintosh.TM. and Windows.TM. PC based operating systems, the PostScript.TM. programming language is typically built into special printers or printer accessories, however, software emulators and on-screen pre-viewers are also available. In use in such operating systems, the operating system and device driver software collaborate automatically to construct a PostScript.TM. programming language program file (such program file typically includes embedded data such as ASCII versions of text to be rendered) that fully describes an entire page to be rendered. Then, the operating system causes the device driver to download the PostScript.TM. programming language program file, along with any other necessary files, to the printer which, in turn, executes the PostScript.TM. programming language program file and prints the result. A PostScript.TM. programming language embodiment of a font is problematic for Apple.TM. Macintosh.TM. and Windows.TM. PC based operating systems because these PostScript.TM. programming language fonts are not built into these operating systems and, hence, cannot provide live, as-you-edit display (however, some UNIX.TM. based operating systems support live, as-you edit display of PostScript.TM. programming language fonts). It should be noted, however, that a prior art product called the Adobe.TM. Type Manager ("ATM") for use with Windows.TM. PC and Apple.TM. Macintosh.TM. platforms, enables any application program to utilize the above-described pure-outline, PostScript.TM. programming language Type 1 format fonts as if they were native to the platform, despite the fact that Microsoft.TM. and Apple.TM. do not support these fonts. When the ATM is loaded, it intercepts font-related operating system calls and monitors them for an operating system request that uses a font name that the ATM recognizes as relating to a Type 1 format font. In that case, the ATM does not pass the request to the native font subsystem. Instead, the ATM masquerades as the native font subsystem and performs the steps required to render the character on the output device using the Type 1 format font or to otherwise satisfy the user program request. In the case of user program requests that require data to be returned from a native font, the ATM converts the appropriate information from the Type 1 format font into a format expected by the user program.
Despite all of the above, pure-outline fonts are problematic for the basic reason that they do not support embedded color information and, as a result, they always render characters with a user-selected color like a rubber stamp.
The third basic prior art font type is referred to as a program font. Program fonts have been embodied in the Adobe.TM. PostScript.TM. programming language Type 3 format font. A program font is scalable and consists of a program and embedded data for each character. In operation, when a user program requests text output, an appropriate program in the font is called by the graphics subsystem for each character to be displayed. The program, and its embedded data, are interpreted to cause appropriate markings to be made on an output device to create each character shape. A typical program font describes, and then causes an outline to be filled or stroked. Adobe.TM. documentation offers the following advice about color in Type 3 format fonts " . . . is useful, for example, in defining characters that incorporate two or more specific opaque colors (e.g. opaque black and opaque white). This is unusual; most characters have no inherent color but are painted with the current color within the character's outline, leaving the area outside unpainted (transparent)."
The fourth basic prior art font type is referred to as a parametric outline font. The parametric outline font is a scalable font that contains typographical shape descriptions (sometimes referred to as parametric font schemes) which, for each character in the alphabet, define shapes and position of lines that enclose filled-in portions of the characters. A typical parametric outline font contains a coded characterization of the font's general look, as well as character-by-character information that describes deviations of each particular character from the font's general look.
Aside from the above-described prior art font technologies, there are other, seemingly-similar technologies, for rendering characters. These seemingly-similar technologies include; for example, clip art, linked objects, paint programs and a few specialized prior art programs. In accordance with clip art technology, many ornate alphabets are presently available as clip art images or drawings. As is well known, to render text using clip art, the user must manually select, paste-in, and position appropriate clip art files, each clip art file representing one letter in a message (the clip art may or may not contain multiple colors). Clip art technology is problematic because it does not permit a user to type desired text which is recognized as such, for example, by a word processor, and it does not provide automatic conversion of text to rendered shapes. Further, clip art is problematic because it is generally not automatically evenly placed on a baseline and spaced by application programs.
In accordance with linked objects technology, a few special programs exist in the market that enable a user to type some text and then to apply color to, and to transform, existing fonts (for example, to make them look three dimensional). It is then possible to link the graphical output of these programs into other programs using a technology such as, for example, Microsoft's OLE. In accordance with this linked objects technology, from the point of view of the user program, for example, Microsoft Word, the text being rendered is not considered to be text. Linked objects technology is problematic because special provisions (other than a graphic subsystem's normal character-rendering API calls) must be made by user programs that want to use linked objects. Further, text to be rendered in color is not stored with the rest of the "ordinary" text data in the user program's memory and files. Indeed, the user program simply views the linked objects as separate windows on the display that are managed by another program, i.e., the user program is unaware of the nature or contents of that window. This is problematic because a word processor cannot "find" a character string which resides in a linked object.
In accordance with generalized computer graphics technology, many generalized paint or draw programs are available in the market that enable an operator to transform or create letter shapes, and add color. However, this paint program technology is problematic because the output of a paint program is essentially a linked object or a custom clip art file.
A first specialized prior art program is entitled Art Importer, also previously entitled KeyMaster. Art Importer creates PostScript.TM. programming language Type 3 format fonts from user-supplied clip art. The resulting PostScript.TM. programming language Type 3 format fonts ignore user-selected color and supply their own color obtained from the user-supplied clip art. In addition, the resulting PostScript.TM. Type 3 format fonts can perform many special effects on, and transformations of, existing fonts. Art Importer was promoted by its manufacturer as enabling users to create fonts that contained symbols like company logos, signatures, and other frequently-used artwork. That is, the character "A" would be rendered as the company's logo. The so-called advantage of having text rendered by a font to produce a logo instead of using conventional clip art to produce the logo was that it would be easier and simpler for a user to scale and position text than clip art. Using the Art Importer font technology, each character is typically rendered in a different shape, using a different color scheme, and having colors applied differently. As a result, the created fonts require separate algorithms for each character. This is problematic since the fonts do not provide characters having a consistent, identifiable look.
A second specialized prior art program is entitled Corel.TM. Depth. Corel.TM. Depth is a program (typical of several similar programs on the market) which receives text to be rendered, a system font to be used in rendering the text, and input data from a user program. The Corel.TM. Depth program contains a library of various styles to apply to the text, for example, the styles include, for example, color information, fade information, extrusion information, and so forth. In use, the Corel.TM. Depth program applies the user selected style to the input text and font to render the text. As one can readily appreciate, Corel.TM. Depth is a special purpose application program and not a font, i.e., a programming construct that is used outside of an application program.
In light of the above, there is a need in the art for method and apparatus for rendering characters on an output device using multiple color fonts ("MCFs"). Further, there is a need in the art for MCFs which are scalable fonts (fonts use to render characters in multiple sizes and output device pixel resolutions) that enable the use of one or more types of color scheme (color design) data and character shape data in conjunction with one or more types of embedded transformation data (shapes and visual looks) to render the characters. Still further, there is a need in the prior art for embodiments of such MCFs that can be used: (a) in coordination with present operating systems; (b) as an annex to application programs; (c) in coordination with, or as an integral part of, an operating-environment; and (d) over the Internet or other computer networks.